home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / finalizr.c < prev    next >
C/C++ Source or Header  |  2000-04-04  |  7KB  |  283 lines
  1. /***************************************************************************
  2.  
  3.   vidhrdw.c
  4.  
  5.   Functions to emulate the video hardware of the machine.
  6.  
  7. ***************************************************************************/
  8.  
  9. #include "driver.h"
  10. #include "vidhrdw/generic.h"
  11.  
  12.  
  13.  
  14. unsigned char *finalizr_scroll;
  15. unsigned char *finalizr_videoram2,*finalizr_colorram2;
  16. static int spriterambank;
  17.  
  18.  
  19.  
  20. void finalizr_vh_convert_color_prom(unsigned char *palette, unsigned short *colortable,const unsigned char *color_prom)
  21. {
  22.     int i;
  23.     #define TOTAL_COLORS(gfxn) (Machine->gfx[gfxn]->total_colors * Machine->gfx[gfxn]->color_granularity)
  24.     #define COLOR(gfxn,offs) (colortable[Machine->drv->gfxdecodeinfo[gfxn].color_codes_start + offs])
  25.  
  26.  
  27.     for (i = 0;i < Machine->drv->total_colors;i++)
  28.     {
  29.         int bit0,bit1,bit2,bit3;
  30.  
  31.  
  32.         /* red component */
  33.         bit0 = (color_prom[0] >> 0) & 0x01;
  34.         bit1 = (color_prom[0] >> 1) & 0x01;
  35.         bit2 = (color_prom[0] >> 2) & 0x01;
  36.         bit3 = (color_prom[0] >> 3) & 0x01;
  37.         *(palette++) = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  38.         /* green component */
  39.         bit0 = (color_prom[0] >> 4) & 0x01;
  40.         bit1 = (color_prom[0] >> 5) & 0x01;
  41.         bit2 = (color_prom[0] >> 6) & 0x01;
  42.         bit3 = (color_prom[0] >> 7) & 0x01;
  43.         *(palette++) = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  44.         /* blue component */
  45.         bit0 = (color_prom[Machine->drv->total_colors] >> 0) & 0x01;
  46.         bit1 = (color_prom[Machine->drv->total_colors] >> 1) & 0x01;
  47.         bit2 = (color_prom[Machine->drv->total_colors] >> 2) & 0x01;
  48.         bit3 = (color_prom[Machine->drv->total_colors] >> 3) & 0x01;
  49.         *(palette++) = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  50.  
  51.         color_prom++;
  52.     }
  53.  
  54.     color_prom += Machine->drv->total_colors;
  55.     /* color_prom now points to the beginning of the lookup tables */
  56.  
  57.     for (i = 0;i < TOTAL_COLORS(1);i++)
  58.     {
  59.         if (*color_prom & 0x0f) COLOR(1,i) = *color_prom & 0x0f;
  60.         else COLOR(1,i) = 0;
  61.         color_prom++;
  62.     }
  63.     for (i = 0;i < TOTAL_COLORS(0);i++)
  64.     {
  65.         COLOR(0,i) = (*(color_prom++) & 0x0f) + 0x10;
  66.     }
  67. }
  68.  
  69. int finalizr_vh_start(void)
  70. {
  71.     dirtybuffer = 0;
  72.     tmpbitmap = 0;
  73.  
  74.     if ((dirtybuffer = malloc(videoram_size)) == 0)
  75.         return 1;
  76.     memset(dirtybuffer,1,videoram_size);
  77.  
  78.     if ((tmpbitmap = osd_new_bitmap(256,256,Machine->scrbitmap->depth)) == 0)
  79.     {
  80.         free(dirtybuffer);
  81.         return 1;
  82.     }
  83.  
  84.     return 0;
  85. }
  86.  
  87. void finalizr_vh_stop(void)
  88. {
  89.     free(dirtybuffer);
  90.     osd_free_bitmap(tmpbitmap);
  91.  
  92.     dirtybuffer = 0;
  93.     tmpbitmap = 0;
  94. }
  95.  
  96.  
  97.  
  98. WRITE_HANDLER( finalizr_videoctrl_w )
  99. {
  100.     spriterambank = data & 8;
  101.  
  102.     /* other bits unknown */
  103. }
  104.  
  105.  
  106.  
  107. /***************************************************************************
  108.  
  109.   Draw the game screen in the given osd_bitmap.
  110.   Do NOT call osd_update_display() from this function, it will be called by
  111.   the main emulation engine.
  112.  
  113. ***************************************************************************/
  114. void finalizr_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  115. {
  116.     int offs;
  117.  
  118.  
  119.     /* for every character in the Video RAM, check if it has been modified */
  120.     /* since last time and update it accordingly. */
  121.     for (offs = videoram_size - 1;offs >= 0;offs--)
  122.     {
  123.         if (dirtybuffer[offs])
  124.         {
  125.             int sx,sy;
  126.  
  127.  
  128.             dirtybuffer[offs] = 0;
  129.  
  130.             sx = offs % 32;
  131.             sy = offs / 32;
  132.  
  133.             drawgfx(tmpbitmap,Machine->gfx[0],
  134.                     videoram[offs] + ((colorram[offs] & 0xc0) << 2),
  135.                     (colorram[offs] & 0x0f),
  136.                     colorram[offs] & 0x10,colorram[offs] & 0x20,
  137.                     8*sx,8*sy,
  138.                     0,TRANSPARENCY_NONE,0);
  139.         }
  140.     }
  141.  
  142.  
  143.     /* copy the temporary bitmap to the screen */
  144.     {
  145.         int scroll;
  146.  
  147.  
  148.         scroll = -*finalizr_scroll + 16;
  149.  
  150.         copyscrollbitmap(bitmap,tmpbitmap,1,&scroll,0,0,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  151.     }
  152.  
  153.  
  154.     /* Draw the sprites. */
  155.     {
  156.         unsigned char *sr;
  157.  
  158.  
  159.         if (spriterambank != 0)
  160.             sr = spriteram_2;
  161.         else sr = spriteram;
  162.  
  163.         for (offs = 0;offs < spriteram_size;offs += 5)
  164.         {
  165.             int sx,sy,flipx,flipy,code,color;
  166.  
  167.  
  168.             sx = 16 + sr[offs+3] - ((sr[offs+4] & 0x01) << 8);
  169.             sy = sr[offs+2];
  170.             flipx = sr[offs+4] & 0x20;
  171.             flipy = sr[offs+4] & 0x40;
  172.             code = sr[offs] + ((sr[offs+1] & 0x0f) << 8);
  173.             color = ((sr[offs+1] & 0xf0)>>4);
  174.  
  175. //            (sr[offs+4] & 0x02) is used, meaning unknown
  176.  
  177.             switch (sr[offs+4] & 0x1c)
  178.             {
  179.                 case 0x10:    /* 32x32? */
  180.                 case 0x14:    /* ? */
  181.                 case 0x18:    /* ? */
  182.                 case 0x1c:    /* ? */
  183.                     drawgfx(bitmap,Machine->gfx[1],
  184.                             code,
  185.                             color,
  186.                             flipx,flipy,
  187.                             flipx?sx+16:sx,flipy?sy+16:sy,
  188.                             &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  189.                     drawgfx(bitmap,Machine->gfx[1],
  190.                             code + 1,
  191.                             color,
  192.                             flipx,flipy,
  193.                             flipx?sx:sx+16,flipy?sy+16:sy,
  194.                             &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  195.                     drawgfx(bitmap,Machine->gfx[1],
  196.                             code + 2,
  197.                             color,
  198.                             flipx,flipy,
  199.                             flipx?sx+16:sx,flipy?sy:sy+16,
  200.                             &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  201.                     drawgfx(bitmap,Machine->gfx[1],
  202.                             code + 3,
  203.                             color,
  204.                             flipx,flipy,
  205.                             flipx?sx:sx+16,flipy?sy:sy+16,
  206.                             &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  207.                     break;
  208.  
  209.                 case 0x00:    /* 16x16 */
  210.                     drawgfx(bitmap,Machine->gfx[1],
  211.                             code,
  212.                             color,
  213.                             flipx,flipy,
  214.                             sx,sy,
  215.                             &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  216.                     break;
  217.  
  218.                 case 0x04:    /* 16x8 */
  219.                     code = ((code & 0x3ff) << 2) | ((code & 0xc00) >> 10);
  220.                     drawgfx(bitmap,Machine->gfx[2],
  221.                             code & ~1,
  222.                             color,
  223.                             flipx,flipy,
  224.                             flipx?sx+8:sx,sy,
  225.                             &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  226.                     drawgfx(bitmap,Machine->gfx[2],
  227.                             code | 1,
  228.                             color,
  229.                             flipx,flipy,
  230.                             flipx?sx:sx+8,sy,
  231.                             &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  232.                     break;
  233.  
  234.                 case 0x08:    /* 8x16 */
  235.                     code = ((code & 0x3ff) << 2) | ((code & 0xc00) >> 10);
  236.                     drawgfx(bitmap,Machine->gfx[2],
  237.                             code & ~2,
  238.                             color,
  239.                             flipx,flipy,
  240.                             sx,flipy?sy+8:sy,
  241.                             &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  242.                     drawgfx(bitmap,Machine->gfx[2],
  243.                             code | 2,
  244.                             color,
  245.                             flipx,flipy,
  246.                             sx,flipy?sy:sy+8,
  247.                             &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  248.                     break;
  249.  
  250.                 case 0x0c:    /* 8x8 */
  251.                     code = ((code & 0x3ff) << 2) | ((code & 0xc00) >> 10);
  252.                     drawgfx(bitmap,Machine->gfx[2],
  253.                             code,
  254.                             color,
  255.                             flipx,flipy,
  256.                             sx,sy,
  257.                             &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  258.                     break;
  259.             }
  260.         }
  261.     }
  262.  
  263.     for (offs = videoram_size - 1;offs >= 0;offs--)
  264.     {
  265.         int sx,sy;
  266.  
  267.  
  268.         sx = offs % 32;
  269.         if (sx < 6)
  270.         {
  271.             if (sx >= 3) sx += 30;
  272.             sy = offs / 32;
  273.  
  274.             drawgfx(bitmap,Machine->gfx[0],
  275.                     finalizr_videoram2[offs] + ((finalizr_colorram2[offs] & 0xc0) << 2),
  276.                     (finalizr_colorram2[offs] & 0x0f),
  277.                     finalizr_colorram2[offs] & 0x10,finalizr_colorram2[offs] & 0x20,
  278.                     8*sx,8*sy,
  279.                     &Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  280.         }
  281.     }
  282. }
  283.